home *** CD-ROM | disk | FTP | other *** search
/ The Fatted Calf / The Fatted Calf.iso / Modules / BackSpaceModules / Source / Alarm / AlarmView.m < prev    next >
Text File  |  1992-09-13  |  9KB  |  429 lines
  1. #import "AlarmView.h"
  2. #import <appkit/appkit.h>
  3. #import <sys/time.h>
  4. #import <dpsclient/wraps.h>  // For PSxxx functions...
  5.  
  6. #import "Alarm.h"
  7.  
  8. static char pathname[1024];
  9.  
  10. static BOOL getOpenPath(char *buf, char const *theType)
  11. {
  12.     static id openPanel = nil;
  13.     char const *fileTypes[2] = {0,0};
  14.     int opr;
  15.  
  16.     if (!openPanel)
  17.         openPanel = [OpenPanel new];
  18.     if (theType && *theType)
  19.     fileTypes[0] = theType;
  20.     [NXApp setAutoupdate:NO];
  21.     
  22.     if (*buf)
  23.       opr = [openPanel runModalForDirectory:buf
  24.          file:NULL types:fileTypes];
  25.     else
  26.       opr = [openPanel runModalForDirectory:"/NextLibrary/Sounds" 
  27.      file:"Basso.snd" types:fileTypes];
  28.     if (opr) {
  29.     strcpy(buf,[openPanel filename]);
  30.     [NXApp setAutoupdate:YES];
  31.     return YES;
  32.     } else {
  33.     [NXApp setAutoupdate:YES];
  34.     return NO;
  35.     }
  36. }
  37.  
  38. @implementation AlarmView
  39.  
  40. - initFrame:(const NXRect *) frameRect
  41. {
  42.   loc.x = bounds.size.width/2;
  43.   loc.y = bounds.size.height/2;
  44.   font = [Font newFont:"Times-Bold" size:64.0 matrix:NX_IDENTITYMATRIX];
  45.   font = [[FontPanel new] panelConvertFont:font];
  46.   [inspectorPanel display];
  47.   time = [[Alarm alloc] init];
  48.   strcpy(timestr,[time timeString]);
  49.   [time setDelegate:self];
  50.   [font_name setStringValue:"Times-Bold 64"];
  51.   return [super initFrame:frameRect];
  52. }
  53.  
  54. - readDefaults
  55. {
  56.     const char *def_sound, *def_font, *def_mode, *def_time;
  57.     float fsize;
  58.     char fname[FILENAME_MAX];
  59.     int dhour, dmin;
  60.     
  61.     def_sound = NXGetDefaultValue([NXApp appName], "AlarmSound");
  62.     if (!def_sound)
  63.         def_sound = "/NextLibrary/Sounds/Rooster.snd";
  64.     [self openFile:(char *)def_sound];
  65.     def_font = NXGetDefaultValue([NXApp appName], "AlarmFont");
  66.     if (def_font && (sscanf(def_font,"%s %f",fname,&fsize) == 2)) {
  67.         font = [Font newFont:fname size:fsize matrix:NX_IDENTITYMATRIX];
  68.         font = [[FontPanel new] panelConvertFont:font];
  69.         [font_name setStringValue:def_font];
  70.     }
  71.     def_mode = NXGetDefaultValue([NXApp appName], "AlarmMode");
  72.     if (def_mode && strcmp(def_mode,"FADING"))
  73.             [slide_fade selectCellAt:0 :1];
  74.     def_time = NXGetDefaultValue([NXApp appName], "AlarmTime");
  75.     if (def_time && (sscanf(def_time,"%d:%d",&dhour ,&dmin) == 2)) 
  76.     {
  77.         dhour = [self validHour:dhour];
  78.         if (dmin < 0 || dmin > 59) dmin = 0;
  79.         [time setAlarmTime:dhour :dmin];
  80.         [self formatAlarmFields];
  81.     }
  82.     return self;
  83. }
  84.  
  85. - setFade:sender
  86. {
  87.     slide = [sender selectedRow];
  88.     if (slide)
  89.         NXWriteDefault([NXApp appName], "AlarmMode", "Fade");
  90.     else
  91.         NXWriteDefault([NXApp appName], "AlarmMode", "Slide");
  92.     return self;
  93. }
  94.  
  95. - oneStep
  96. {
  97.   if (slide)
  98.       [self moveTime];
  99.   else
  100.       [self dissolveTime];
  101.   return self;
  102. }
  103.  
  104. - eraseTime
  105. {
  106.     PSsetgray(0.0);
  107.     PSmoveto(loc.x,loc.y);
  108.     PSshow(timestr);
  109.     return self;
  110. }
  111.  
  112. - drawTime
  113. {
  114.     if (font_changed) {
  115.         font_changed = NO;
  116.         font = newfont;
  117.         [font set];
  118.     }
  119.     PSsetgray(timeGray);
  120.     PSmoveto(loc.x,loc.y);
  121.     PSshow(timestr);
  122.     return self;
  123. }
  124.  
  125. - dissolveTime
  126. {
  127.   static float x, y, dis = 1.0, da = -0.005;
  128.  
  129.   [self eraseTime];
  130.   strcpy(timestr,[time timeString]);
  131.   PSstringwidth(timestr,&x,&y);
  132.   timeGray = dis;
  133.   if (dis >= 0.0 && dis <= 1.0)
  134.   {
  135.     dis += da;
  136.   } else {
  137.     da *= -1;
  138.     if (dis < 0.0) {
  139.         loc.x = ( (random()&32767) / 32767.0) * (bounds.size.width - x);
  140.         loc.y = ( (random()&32767) / 32767.0) * (bounds.size.height - y);
  141.     }
  142.     dis += da;  
  143.   }
  144.   [self drawTime];
  145.   return self;
  146. }
  147.  
  148. - moveTime
  149. {
  150.   static float dx = 0.2, dy = 0.4;
  151.   static float x, y, tmpy, tmpx;
  152.   
  153.   [self eraseTime];
  154.   strcpy(timestr,[time timeString]);
  155.   PSstringwidth(timestr,&x,&y);
  156.   timeGray = NX_LTGRAY;
  157.   if (fabs(tmpx) >= 1)
  158.   {
  159.     loc.x += dx / (fabs(dx));
  160.     tmpx = 0;
  161.     if (((loc.x + x >= bounds.size.width) && (dx > 0)) ||
  162.           ((loc.x <= 0.0) && (dx < 0)))
  163.     {
  164.         dx = - (dx / (fabs(dx))) * ((random()&32767) / 32767.0);
  165.     }
  166.   } else   tmpx += dx;
  167.   if (fabs(tmpy) >= 1)
  168.   {
  169.     loc.y += dy / (fabs(dy));
  170.     tmpy = 0;
  171.     if (((loc.y + 64.0 >= bounds.size.height) && (dy > 0)) ||
  172.               ((loc.y <= 0.0) && (dy < 0)))
  173.     {
  174.         dy = - (dy / (fabs(dy))) * ((random()&32767) / 32767.0);
  175.     }
  176.   } else   tmpy += dy;
  177.   [self drawTime];
  178.   return self;
  179. }
  180.  
  181. - inspector:sender
  182. {
  183.   char buf[MAXPATHLEN];
  184.   
  185.   if (!inspectorPanel)
  186.     {
  187.       sprintf(buf,"%s/Alarm.nib",(char *)[sender moduleDirectory:"Alarm"]);
  188.       [NXApp loadNibFile:buf owner:self withNames:NO];
  189.     }
  190.   [self readDefaults];
  191.   [self makeDummyFirstResponder];
  192.   return inspectorPanel;
  193. }
  194.  
  195. - (BOOL)useBufferedWindow
  196. {
  197.   return YES;
  198. }
  199.  
  200.  
  201. - (const char *)windowTitle
  202. {
  203.   return "Alarm!";
  204. }
  205.  
  206.  
  207. - openFile:(char *)fileName
  208. {
  209.     id newSound;
  210.     newSound = [[Sound alloc] initFromSoundfile:fileName];
  211.     [self setAlarmSound:newSound];
  212.     [sound_name setStringValue:(strrchr(fileName,'/') + 1)];
  213.     return self;
  214. }
  215.  
  216. - open:sender
  217. {
  218.     if (getOpenPath(pathname,"snd")) {
  219.         [self openFile:pathname];
  220.         NXWriteDefault([NXApp appName], "AlarmSound", pathname);
  221.     }
  222.     return self;
  223. }
  224.  
  225. - setAlarmSound:newsound
  226. {
  227.     [alarmSound free];
  228.     alarmSound = newsound;
  229.     [alarmSound setDelegate:self];
  230.     return self;
  231. }
  232.  
  233. - playAlarmSound:sender
  234. {
  235.     NXEvent dummy;
  236.     if (([alarmSound status] == NX_SoundPlaying) && (sender != self))
  237.         [alarmSound stop];
  238.     else
  239.         [alarmSound play];
  240.     // we do this so that sounds actually play when we're in screensaver
  241.     // mode.  It's necessary because BackSpace doesn't read in events when
  242.     // in screensaver mode, and the soundkit depends on receiving messages from
  243.     // the sound-playing thread.
  244.     [NXApp peekNextEvent:NX_ALLEVENTS into:&dummy];
  245.     return self;
  246. }
  247.  
  248. - alarm:sender
  249. {
  250.     [self playAlarmSound:self];
  251.     return self;
  252. }
  253.  
  254. - formatAlarmFields
  255. {
  256.     char tmp[10];
  257.     int h, m;
  258.     
  259.     h = [time alarmHour];
  260.     m = [time alarmMinute];
  261.     [hourSlider setIntValue:h];
  262.     [minSlider setIntValue:m];
  263.     sprintf(tmp,"%d:%d",h,m);
  264.     NXWriteDefault([NXApp appName], "AlarmTime", tmp);
  265.     if (h == 0)
  266.         h = 12;
  267.     if (h > 12) h -= 12;
  268.     sprintf (tmp, "%02d",h);
  269.     [aHour setStringValue:tmp];
  270.     sprintf (tmp, "%02d",m);
  271.     [aMin setStringValue:tmp];
  272.     return self;
  273. }
  274.  
  275. - (int) validHour:(int)val
  276. {
  277.     if (val < 0 || val >= 24)
  278.         return [time alarmHour];
  279.     if (val < 12)
  280.     {
  281.         [am_pm selectCellAt:0 :0];
  282.         return val;
  283.     }
  284.     [am_pm selectCellAt:1 :0];
  285.     return val;
  286. }
  287.  
  288. - setTime:sender
  289. {
  290.     int h, m;
  291.     h = [aHour intValue];
  292.     h = [self validHour:h];
  293.     m = [aMin intValue];
  294.     if (m < 0 || m > 59)
  295.         m = [time alarmMinute];
  296.     [time setAlarmTime:h :m];
  297.     [self formatAlarmFields];
  298.     [self resetAlarm];
  299.     return self;
  300. }
  301.  
  302. - setTimeWithSlider:sender
  303. {
  304.     int h, m;
  305.     h = [hourSlider intValue];
  306.     m = [minSlider intValue];
  307.     h = [self validHour:h];
  308.     [time setAlarmTime:h :m];
  309.     [self formatAlarmFields];
  310.     [self resetAlarm];
  311.     return self;
  312. }
  313.  
  314. - resetAlarm
  315. {
  316.     // if the alarm might be ringing, reset it so that it stops
  317.     if ([time alarmState]) {
  318.         [time setAlarmState:NO];
  319.         [time setAlarmState:YES];
  320.         if ([alarmSound status] == NX_SoundPlaying)
  321.             [alarmSound stop];
  322.     }
  323.     return self;
  324. }
  325.  
  326. - setAlarm:sender
  327. {
  328.     if ((BOOL)[sender intValue] == NO)
  329.         [alarmSound stop];
  330.     [time setAlarmState:(BOOL)[sender intValue]];
  331.     return self;
  332. }
  333.  
  334.  
  335. // the following is a set of hacks so we can get the font panel to set
  336. // info on something that really isn't the first responder... 
  337. // it's very gross, you probably want to ignore it.
  338.  
  339. - (BOOL) acceptsFirstResponder
  340. {
  341.     return YES;
  342. }
  343.  
  344. - makeDummyFirstResponder
  345. {
  346.     NXRect frm;
  347.     NXSetRect(&frm,0,0,1,1);
  348.     dummyView = [[DummyResponderView alloc] initFrame:&frm];
  349.     [inspectorPanel addSubview:dummyView];
  350.     [dummyView setDelegate:self];
  351.     return self;
  352. }
  353.  
  354. - changeFont:sender
  355. {
  356.     char fontname[1024];
  357.     id mgr;
  358.     mgr = [FontManager new];
  359.     newfont = [mgr convertFont:font];
  360.     font_changed = YES;
  361.     sprintf (fontname,"%s %f",[newfont name],[newfont pointSize]);
  362.     NXWriteDefault([NXApp appName], "AlarmFont", fontname);
  363.     [font_name setStringValue:fontname];
  364.     return self;
  365. }
  366.  
  367. - setAlarmFont:sender
  368. {
  369.     id mgr;
  370.     
  371.     mgr = [FontManager new];
  372.     // for some weird reason, the panel must be ordered front
  373.     // before the setSelFont will work.
  374.     [mgr orderFrontFontPanel:sender];
  375.     [mgr setSelFont:font isMultiple:NO];
  376.     [[inspectorPanel window] makeFirstResponder:dummyView];
  377.     [[self window] makeFirstResponder:self];
  378.     return self;
  379. }
  380.  
  381. // BackSpace delegate methods
  382.  
  383. - enteredScreenSaverMode
  384. {
  385.     [time resetRinger];
  386.     return self;
  387. }
  388.  
  389. - willExitScreenSaverMode
  390. {
  391.     [alarmSound stop];
  392.     return self;
  393. }
  394.  
  395. - newWindow
  396. {
  397.     [self becomeFirstResponder];
  398.     return self;
  399. }
  400.  
  401. - didLockFocus
  402. {
  403.     [font set];
  404.     return self;
  405. }
  406.  
  407. @end;
  408.  
  409.  
  410. @implementation DummyResponderView
  411.  
  412. - setDelegate:sender
  413. {
  414.     delegate = sender;
  415.     return self;
  416. }
  417.  
  418. - (BOOL)acceptsFirstResponder
  419. {
  420.     return YES;
  421. }
  422.  
  423. - changeFont:newfont
  424. {
  425.     [delegate changeFont:newfont];
  426.     return self;
  427. }
  428.  
  429. @end;